home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
HPAVC
/
HPAVC CD-ROM.iso
/
PASCTXT.ZIP
/
CHAP5.TXT
< prev
next >
Wrap
Text File
|
1988-01-15
|
28KB
|
653 lines
CHAPTER 5 - The Pascal procedures and functions
In order to properly define procedures and functions we
need to lay some groundwork in the form of a few
definitions. These are important concepts, so pay close
attention.
Program Heading - This is the easiest part since it is only
one line, at least it has been in all of our
programs up to this point. It is simply the
"program" line, and it never needs to be any more
involved than it has been up to this point in
TURBO Pascal.
Declaration Part - This is the part of the Pascal source
code in which all constants, variables, and user
defined auxiliary operations are defined. In
some of the programs we have examined, there have
been one or more var declarations. These are the
only components of the declaration part we have
used to this point. There are actually five
components in the declaration part, and the
procedures and functions are the fifth part. We
will cover the others in the next chapter.
Statement Part - This is the last part of any Pascal
program, and it is what we have been calling the
main program. It is one compound statement
bracketed with the reserved words "begin" and
"end".
It is very important that you grasp the above
definitions because we will be referring to them constantly
during this chapter, and throughout the remainder of this
tutorial. With that introduction, lets go on to our first
Pascal program with a procedure in it, in fact, it will have
three procedures.
THE FIRST PROCEDURES
Load PROCED1 as your first example file with a
procedure and display it on your monitor. You will notice
that it doesn't look like anything you have seen up to this
point because it has procedures in it. Lets go back to our
definitions from above. The first line is the Program
Heading which should pose no difficulty. The Declaration
Part begins with the var statement in line 4 and continues
down through and including all three procedures ending in
line 19. Lines 21 through 26 constitute the Statement Part.
It may seem strange that what appears to be executable
Pascal statements, and indeed they are executable
statements, are contained in the Declaration Part rather
than the Statement Part. This is because of the Pascal
Page 26
CHAPTER 5 - The Pascal procedures and functions
definition and it will make sense when we have completed our
study of procedures and functions.
Continuing to examine PROCED1, we will make note of the
program itself, which is the Statement Part. The program,
due to the nature of Pascal and the carefully chosen
procedure names, clearly tells us what it will do. It will
write a header, eight messages, and an ending. The only
problem we are faced with is, how will it write these
messages? This is where the Declaration Part is called upon
to define these operations in detail. The Declaration Part
contains the three procedures which will completely define
what is to be done by the procedure calls in the main
program.
It should be clear to you that the definitions of the
procedures should be in the Definition Part of the program
because that is exactly what they do. In the case of a
var, a variable is defined for later use by the main
program, and in the case of a procedure, the procedure
itself is defined for later use by the main program.
Lets arbitrarily pick one of the procedures, the first,
and examine it in detail. The first executable statement we
come to in the main program is line 22 and says simply,
Write_A_Header, followed by the usual end of statement, the
semicolon. This is a simple procedure call. When the
compiler finds this statement it goes looking for a
predefined procedure of that name which it can execute. If
it finds one in the Declaration Part of the program, it will
execute that procedure. If it doesn't find a user defined
procedure, it will search the Pascal library for a system
defined procedure and execute it. The Write and Writeln
statements are system procedures, and you have already been
using them quite a bit, so procedures are not completely new
to you. If it doesn't find the procedure defined in either
place, it will generate an error message.
HOW TO CALL A PROCEDURE
To call a procedure, we simply need to state its name.
To define a simple procedure, we use the reserved word
"procedure" followed by its calling name, with a semicolon
as a terminator. Following the Procedure Heading, there is
the Declaration Part of the procedure followed by a body
which is nothing more than a compound statement bracketed by
the reserved words "begin" and "end". This is identical to
the Statement Part of the main program except that the
procedure ends with a semicolon instead of a period. Any
valid Pascal statements can be put between the begin and
Page 27
CHAPTER 5 - The Pascal procedures and functions
end, and in fact, there is no difference in what can be put
in a procedure and what can be put in the main program.
The program we are examining would be no different if
we would eliminate the first procedure completely and move
the Writeln contained in it down to the Statement Part in
place of Write_A_Header. If that is not clear, go back and
reread the last two paragraphs until it is.
Lines 23 and 24 will cause the procedure named
Write_A_Message to be called 8 times, each time writing a
line of output. Suffice it to say at this time that the
value of the variable Count, as defined here, is available
globally, meaning anywhere in the entire Pascal program. We
will define the scope of variables shortly. Finally, the
last procedure call is made, causing the ending message to
be displayed, and the program execution is complete.
Having examined your first Pascal procedures, there is
a fine point that is obvious but could be easily overlooked.
We mentioned the unbroken rule of Pascal in an earlier
chapter and it must be followed here too. "Nothing can be
used in Pascal until it has been defined". The procedures
must all be defined ahead of any calls to them, once again
emphasizing the fact that they are part of the Declaration
Part of the program, not the Statement Part.
Compile and run PROCED1 to verify that it does what you
expect it to do.
MORE PROCEDURE CALLS
Assuming you have run PROCED1 successfully and
understand its output, lets go on to PROCED2 and examine it.
In this program we will see how to call a procedure and take
along some data for use within the procedure. To begin
with, notice that there are three procedure calls in the
Statement Part of the program and each has an additional
term not contained in the calls in the last program, namely
the variable name Index within brackets. This is Pascals
way of taking a variable parameter to the procedure when it
is called.
You will notice that the variable Index is defined as
an integer variable in the very top of the Declaration Part.
Since we are taking an integer type variable along when we
visit the procedure Print_Data_Out, it had better be
expecting an integer variable as input or we will have a
type mismatch. In fact, observing the procedure heading
itself in line 7, indicates that it is indeed expecting an
integer variable but it prefers to call the variable Puppy
Page 28
CHAPTER 5 - The Pascal procedures and functions
inside of the procedure. Calling it something different
poses no problem as long as the main program doesn't try to
call its variable Puppy, and the procedure doesn't try to
use the name Index. Both are actually referring to the same
piece of data but they simply wish to refer to it by
different names.
Observe that the next procedure is called with Index as
a parameter and the procedure prefers to call it by the name
Cat. In both cases, the procedures simply print out the
parameter passed to it, and each then try to modify the
value passed to it before passing it back. We will see that
one will be successful and the other will not.
We are in a loop in which Count is incremented from 1
to 3 and Pascal does not allow us to modify the loop
variable so we make a copy of the value in line 21 and call
it Index. We can then modify Index in the main program if
we desire.
CALL BY VALUE
In line 7, the procedure heading does not contain a var
in front of the passed parameter and therefore the parameter
passing is only one way because of the way Pascal is
defined. Without the reserved word var in front of the
variable Puppy, the system makes a copy of Index, and passes
the copy to the procedure which can do anything with it,
using its new name, Puppy, but when control returns to the
main program, the original value of Index is still there.
The copy of Index named Puppy is modified in the procedure,
but the original variable Index remains unchanged. So you
can think of the passed parameter without the var as one way
parameter passing. This is a "call by value" because only
the value of the variable is passed to the procedure.
CALL BY REFERENCE
In line 13, the second procedure has the reserved word
"var" in front of its desired name for the variable, namely
Cat, so it can not only receive the variable, it can modify
it, and return the modified value to the main program. A
copy is not made, but the original variable named Index is
actually passed to this procedure and the procedure can
modify it, therefore communicating with the main program.
The name Catin the procedure is actually another name for
the variable named Index in the main program. A passed
parameter with a var in front of it is therefore a two way
situation. This is a "call by reference" since the
reference to the original variable is passed to the
procedure.
Page 29
CHAPTER 5 - The Pascal procedures and functions
SOME NEW TERMINOLOGY
The parameter name in the calling program is referred
to as the actual parameter, and the parameter name in the
procedure is referred to as the formal parameter. In the
last example then, the actual parameter is named Index and
the formal parameter in the procedure is named Cat. It
should be pointed out that it is called a formal parameter
whether it is a "call by reference" or a "call by value".
This terminology is used in many other programming
languages, not only in Pascal.
When you run this program, you will find that the first
procedure is unable to return the value of 12 back to the
main program, but the second procedure does in fact succeed
in returning its value of 35 to the main program. Spend as
much time as you like studying this program until you fully
understand it. It should be noted that as many parameters
as desired can be passed to and from a procedure by simply
making a list separated by commas in the calls, and
separated by semicolons in the procedure. This will be
illustrated in the next example program.
Compile and run PROCED2 and study the output. You
should be able to comprehend all of the output. If it is
not clear, reread the last few paragraphs.
For your own enlightenment, examine PROCED3 for an
example of a procedure call with more than one variable in
the call. Normally, you would group the three input values
together to make the program more readable, but for purposes
of illustration, they are separated. Observe that the
variable Fruit is a two way variable because it is the 3rd
variable in the actual parameter list and corresponds to the
3rd formal parameter in the procedure header.
Compile and run PROCED3 to see that it does what you
expect it to do based on the above explanation.
"CALL BY REFERENCE" OR "CALL BY VALUE"?
It may seem to you that it would be a good idea to
simply put the word var in front of every formal parameter
in every procedure header to gain maximum flexibility, but
using all "call by references" could actually limit your
flexibility. There are two reasons to use "call by value"
variables when you can. First is simply to shield some data
from being corrupted by the procedure. This is becoming a
very important topic is Software Engineering known as
"information hiding" and is the primary basis behind Object
Page 30
CHAPTER 5 - The Pascal procedures and functions
Oriented Programming which is far beyond the scope of this
tutorial.
Secondly is the ability to use a constant in the
procedure call. Modify line 17 of PROCED3 as follows;
Add_The_Fruit(12,Orange,Fruit,Pear);
and compile and run the program. Since Value1 is a "call by
value", the constant 12 can be used and the program will
compile and run. However, if you change line 17 to;
Add_The_Fruit(Apple,Orange,32,Pear);
you will find that it will not compile because Total is a
"call by reference" and the system must be able to return a
value for the formal parameter Total. It cannot do this
because 32 is a constant, not a variable.
The prior discussion should indicate to you that both
"call by value" and "call by reference" have a useful place
in Pascal programming and it is up to you to decide which
you should use.
When you are satisfied with the present illustration,
we will go on to study the scope of variables using PROCED4.
A MULTIPLY DEFINED VARIABLE
If you will examine PROCED4, you will notice that the
variable Count is defined twice, once in the main program
var block and once in the var block contained within the
procedure named Print_Some_Data. This is perfectly legal
and is within the Pascal definition.
The variable Index is defined only in the main program
var block and is valid anywhere within the entire Pascal
program, including the procedures. The variable Count is
also defined in the main program var block and is valid
anywhere within the entire Pascal program, except within the
procedure where another variable is defined with the same
name Count. The two variables with the same name are in
fact, two completely different variables, one being
available only outside of the procedure and the other being
available only within the procedure. The variable
More_Stuff is defined within the procedure, so it is
invisible to the main program, since it is defined at a
lower level than that of the main program.
Any variable is available at any point in the program
following its definition but only at the level of definition
Page 31
CHAPTER 5 - The Pascal procedures and functions
or below. This means that any procedure in the Declaration
Part of a program can use any variable defined in the
Declaration Part of the program provided that the definition
occurs prior to the procedure. Any variable defined in a
procedure cannot be used by the main program since the
definition is at a lower level than the main program.
Be sure to compile and run PROCED4 before continuing on
to the next example program.
PROCEDURES CALLING OTHER PROCEDURES
Load and examine PROCED5 to see an example of
procedures that call other procedures. Keep in mind that,
"Nothing can be used in Pascal until it has been previously
defined", and the order of procedures will be clear in this
example. Note that procedure Three calls procedure Two
which in turn calls procedure One.
Compile and run PROCED5 and study the output until you
understand why it outputs each line in the order that it
does.
Now that you have a good working knowledge of
procedures, we need to make another important point.
Remember that any Pascal program is made up of three parts,
the Program Heading, the Declaration Part, and the Statement
Part. The Declaration Part is composed of five unique
components, four of which we will discuss in detail in the
next chapter, and the last component, which is composed of
some number of procedures and functions. We will cover
functions in the next example, so for now simply accept the
fact that it is like a procedure. A procedure is also
composed of three parts, a Procedure Heading, a Declaration
Part, and a Statement Part. A procedure, by definition, is
therefore nothing more or less than another complete Pascal
program embedded within the main program, and any number of
procedures can be located in the Declaration Part of the
main program. These procedures are all in a line, one right
after another.
Since a procedure is defined like the main program, it
would seem to be possible to embed another procedure within
the Declaration Part of any procedure. This is perfectly
valid and is often done, but remember that the embedded
procedure can only be called by the procedure in which it is
embedded, not by the main program. This is a form of
information hiding which is becoming popular in modern
software engineering.
Page 32
CHAPTER 5 - The Pascal procedures and functions
The previous paragraph is probably a bit difficult to
grasp. Don't worry about it too much now, as you become
proficient as a Pascal programmer, you will very clearly see
how that is used.
NOW LET'S LOOK AT A FUNCTION
Now to keep a promise, lets examine the program named
FUNCTION to see what a function is and how to use it. In
this very simple program, we have a function that simply
multiplies the sum of two variables by 4 and returns the
result. The major difference between a function and a
procedure is that the function returns a single value and is
called from within a mathematical expression, a Writeln
command, or anywhere that it is valid to use a variable,
since it is really a variable itself. Observing the
Function Heading of the function, in line 6, reveals the two
input variables inside the parenthesis pair being defined as
integer variables, and following the parenthesis is a colon
and another "integer". The last "integer" is used to define
the type of the variable being returned to the main program.
Any call to this function is actually replaced by an
integer upon completion of the call. Therefore in line 14,
the function is evaluated and the value returned is used in
place of the function call. The result of the function is
assigned to the variable Feet.
Note that a function always returns a value and it may
return additional values if some of its parameters are
defined as "call by reference". Be sure to compile and run
this program.
NOW FOR THE MYSTERY OF RECURSION
One of the great mysteries of Pascal to many people, is
the recursion of procedure calls. Simply defined, recursion
is the ability of a procedure to call itself. Examine the
Pascal example file RECURSON for an example of recursion.
The main program is very simple, it sets the variable Count
to the value 7 and calls the procedure Print_And_Decrement.
The procedure prefers to refer to the variable by the name
Index but that poses no problem for us because we understand
that the name of the formal parameter can be any legal
identifier. The procedure writes a line to the video
display with the value of Index written within the line, and
decrements the variable.
The if statement introduces the interesting part of
this program. If the variable is greater than zero, and it
is now 6, then the procedure Print_And_Decrement is called
Page 33
CHAPTER 5 - The Pascal procedures and functions
once again. This might seem to create a problem except for
the fact that this is perfectly legal in Pascal. Upon
entering the procedure the second time, the value of Index
is printed as 6, and it is once again decremented. Since it
is now 5, the same procedure will be called again, and it
will continue until the value of Index is reduced to zero
when each procedure call will be completed one at a time and
control will return to the main program.
ABOUT RECURSIVE PROCEDURES
This is really a stupid way to implement this
particular program, but it is the simplest recursive program
that can be written and therefore the easiest to understand.
You will have occasional use for recursive procedures, so
don't be afraid to try them. Remember that the recursive
procedure must have some variable converging to something,
or you will have an infinite loop.
Compile and run this program and observe the value
decrementing as the recursion takes place.
THE FORWARD REFERENCE
Occasionally you will have a need to refer to a
procedure before you can define it. In that case you will
need a forward reference. The program FORWARD has an
example of a forward reference in it. In this program, each
one of the procedures calls the other, a form of recursion.
This program, like the last, is a very stupid way to count
from 7 to 0, but it is the simplest program possible with
the forward reference.
The first procedure, Write_A_Line, has its header
defined in exactly the same manner as any other procedure
but instead of the normal procedure body, only the reserved
word "forward" is given. This tells the compiler that the
procedure will be defined later. The next procedure is
defined as usual, then the body of Write_A_Line is given
with only the reserved word "procedure" and the procedure
name. The variable reference has been defined earlier. In
this way, each of the procedure names are defined before
they are called.
It would be possible, by using the forward reference in
great numbers, to move the main program ahead of all
procedure definitions and have the program structured like
some other languages. This style of programming would be
perfectly legal as far as the compiler is concerned, but the
resulting program would be very nonstandard and confusing.
You would do well to stick with conventional Pascal
Page 34
CHAPTER 5 - The Pascal procedures and functions
formatting techniques and use the forward reference
sparingly.
Be sure you compile and run this program.
PROGRAMMING EXERCISES
1. Write a program to write your name, address, and phone
number with each Writeln in a different procedure.
2. Add a statement to the procedure in RECURSON to display
the value of "Index" after the call to itself so you can
see the value increasing as the recurring calls are
returned to the next higher level.
3. Rewrite TEMPCONV putting the centigrade to fahrenheit
formulas in a function call.
Page 35
